home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1996 #6 / Amiga Plus CD - 1996 - No. 06.iso / pd / programmierung / stormamiga_lib / stormamiga_lib.dok next >
Text File  |  1996-08-18  |  62KB  |  2,109 lines
  1.  
  2.  
  3.            stormamiga.lib Version 41.035 ( 17.08.1996 )
  4.  
  5.            © Kopierrecht 1996 bei COMPIUTECK
  6.  
  7.              geschrieben von Matthias Henze
  8.  
  9.  
  10.                 F R E E W A R E
  11.  
  12.  
  13.  
  14.  
  15.    Einleitung              Informationen über die stormamiga.lib.
  16.  
  17.    Registrierung           Weshalb man sich registriert.
  18.  
  19.    Systemanforderungen     Was braucht man für die stormamiga.lib?
  20.  
  21.    Installation            Wie installiere ich die stormamiga.lib?
  22.  
  23.    Funktionen              Beschreibung der einzelnen Funktionen.
  24.  
  25.    Beispiele               Beschreibung der Beispielprogramme.
  26.  
  27.    Bekannte Fehler         Wo gibt es Probleme?
  28.  
  29.    Updates                 Wo gibt es neue Versionen?
  30.  
  31.    Kopierrecht             Das Rechtliche.
  32.  
  33.    Geschichte              Was hat sich bisher getan?
  34.  
  35.    In Zukunft              Was wird sich noch ändern?
  36.  
  37.    Danksagungen            Danksagungen an ... .
  38.  
  39.    Autor                   Wie erreicht man den Autor?
  40.  
  41. ============================================================================
  42.  
  43. Einleitung:
  44. ~~~~~~~~~~~
  45.  
  46. Da die Funktionen der "storm.lib" in C geschrieben sind,
  47. werden die damit gelinkten Programme sehr groß und langsam.
  48. Die Funtionen der "amiga.lib" sind auch nicht gerade klein
  49. und schnell.
  50. Aus diesem Grund habe ich mich am 18.03.1996 entschlossen
  51. die "stormamiga.lib" zu schreiben.
  52.  
  53. Die "stormamiga.lib" ist komplett in Assembler geschrieben.
  54. Dadurch werden die damit gelinkten Programme auch sehr klein
  55. und schnell.
  56. Mein Ziel ist es, alle Funtionen der "amiga.lib", die nicht
  57. in den Pragmadateien enthalten sind, und alle Funktionen der
  58. "storm.lib" durch kurze und schnelle Assemblerroutinen zu
  59. ersetzen. Außerdem will ich einige Spezialbefehle von anderen
  60. Compilern (zur Zeit nur vom GCC) und einige Routinen, die das
  61. Programmieren erleichtern, in die "stormamiga.lib" integrieren.
  62.  
  63.  
  64. Wichtig
  65.  
  66. In der jetzigen Version der "stormamiga.lib" sind noch nicht
  67. alle Funktionen der "storm.lib" und der "amiga.lib" enthalten.
  68. Außerdem wird zur Zeit nur das große Code- und Datenmodell
  69. unterstützt.
  70. Bis auf den Startupcode "stormamiga_startups.o" sollte die
  71. "stormamiga.lib" auch mit C++ funktionieren. Allerdings wurde
  72. das noch nicht genügend getestet.
  73.  
  74. ============================================================================
  75.  
  76. Registrierung:
  77. ~~~~~~~~~~~~~~
  78.  
  79. Obwohl die "stormamiga.lib" Freeware ist, was auch so bleiben
  80. wird, können Sie sich bei mir registrieren lassen. Ich möchte
  81. vor allem wissen, ob sich die Weiterentwicklung überhaupt lohnt.
  82.  
  83. Sie können mir natürlich auch Geschenke, die Sie für angemessen
  84. halten, zuschicken. Es währe auch sehr schön, wenn Sie mir Ihr
  85. Programm, bei dem Sie die "stormamiga.lib" verwendet haben,
  86. zuschicken würden. Außerdem würde ich gerne Ihre Meinung zur
  87. "stormamiga.lib" erfahren.
  88.  
  89. Für Fehlerberichte (möglichst mit dem entsprechenden Quelltext
  90. und einer genauen Beschreibung) und Verbesserungsvorschläge bin
  91. ich jederzeit dankbar.
  92. Wenn Sie Fragen zur "stormamiga.lib" haben, können Sie mich gerne
  93. anrufen oder mir schreiben. Ich werde die Antworten zu Ihren
  94. Fragen in der Anleitung der nächsten Version veröffentlichen.
  95. Wenn ich Ihnen die Antworten zu Ihren Fragen persönlich zuschicken
  96. soll, dann müssen Sie mir natürlich einen frankierten Briefumschlag
  97. mitschicken. Wenn ich Ihnen die neueste Version der "stormamiga.lib"
  98. zuschicken soll, dann müssen Sie neben dem frankierten Briefumschlag
  99. auch eine Diskette (HD oder DD) mitschicken.
  100.  
  101. ============================================================================
  102.  
  103. Systemanforderungen:
  104. ~~~~~~~~~~~~~~~~~~~~
  105.  
  106. - Ein Amiga
  107. - AmigaOS 2.0 oder höher
  108. - MC68EC020 oder höher
  109. - StormC Version 1.05 oder höher
  110.  
  111. ============================================================================
  112.  
  113. Installation:
  114. ~~~~~~~~~~~~~
  115.  
  116. Starten Sie das Installationsprogramm "stormamiga.lib HD-
  117. Install" und führen Sie die Installation nach Ihren Wünschen
  118. und Anforderungen durch.
  119.  
  120. Fügen Sie die "stormamiga.lib" an erster Stelle in das
  121. Projekt ein. Da in dieser Version der "stormamiga.lib"
  122. noch nicht alle Funktionen enthalten sind, müssen Sie
  123. noch die "storm.lib" in das Projekt einfügen.
  124. Wenn Sie die Spezialfunktionen der "stormamiga.lib"
  125. nutzen wollen, müssen Sie noch die Includedatei "storm-
  126. amiga.h", mit "#include <stormamiga.h>", in Ihren Quelltext
  127. einbinden. Die Includedatei "stormamiga.h" sollten Sie als
  128. letzte einbinden.
  129. Um auch den neuen Startupcode "stormamiga_startups.o" zu
  130. nutzen, müssen Sie, bei den Linker Optionen der Projekt-
  131. einstellungen, die Option "Eigener Startup-Code" einschal-
  132. ten und die Datei "stormamiga_startups.o" auswählen.
  133.  
  134.  
  135. Wichtig
  136.  
  137. Der Startupcode "stormamiga_startups.o" kann nur für Ansi-C
  138. verwendet werden!
  139.  
  140. ============================================================================
  141.  
  142. Funktionen der "stormamiga.lib"
  143. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  144.  
  145. Da die normalen Ansi-C Funktionen bereits bei StormC
  146. beschrieben werden, erkläre ich nur die Spezialfunktionen
  147. und -befehle.
  148.  
  149. Hinweis
  150. Wenn Sie sich die Map-Datei, eines mit der "stormamiga.lib"
  151. gelinkten Programmes ansehen, werden Sie feststellen, daß
  152. einige Funktionen den Vorsatz "intern__" (z.B. intern__form_in)
  153. besitzen. Diese Funktionen werden in der "stormamiga.lib" nur
  154. intern verwendet und können nicht als Befehle benutzt werden.
  155.  
  156. ============================================================================
  157.  
  158. Der Startupcode "stormamiga_startups.o"
  159.  
  160. Der Startupcode "stormamiga_startups.o" ist speziell für
  161. Ansi-C gedacht.
  162. Der einzige Unterschied, zum Startupcode "startup.o" des
  163. StormC, ist der Aufruf der Funktionen "main" und "wbmain".
  164.  
  165. Der Startupcode "stormamiga_startups.o" ruft die Funtion
  166. "_main__", das entspricht der Funtion "main__()" in Ansi-C,
  167. auf. Wenn es diese Funtion in Ihrem Programm, nicht gibt,
  168. wird sie aus der "stormamiga.lib" dazugelinkt. Die Funktion
  169. "_main__" ruft die Funktion "_main", das entspricht der Funtion
  170. "main()" in Ansi-C, auf. Wenn es diese Funktion nicht gibt,
  171. meldet der Linker einen Fehler.
  172.  
  173. Bei einem Start von der Workbench ruft der Startupcode
  174. "stormamiga_startups.o" die Funtion "_wbmain", das entspricht
  175. der Funtion "wbmain()" in Ansi-C, auf. Wenn es diese Funktion
  176. nicht gibt, wird sie aus der "stormamiga.lib" dazugelinkt.
  177.  
  178.  
  179. Die Funktion "main__()"
  180.  
  181. Wenn Sie für Ihr Programm keine Auswertung von Argumenten
  182. benötigen, können Sie die Funktion "main()"in "main__()"
  183. umbenennen. Dadurch wird Ihr Programm etwas kleiner.
  184.  
  185. Wichtig
  186.  
  187. Da der Compiler die Funktion "main__()" nicht als normale
  188. main-Funktion erkennt, setzt er auch nicht den Returncode
  189. auf 0. Deshalb müssen Sie den Returncode, mit "return 0",
  190. selber auf 0 setzen.
  191. Die Funktion "main__()" benötigt den Startupcode "stormamiga
  192. _startups.o" und funktioniert nur in Ansi-C.
  193.  
  194. ============================================================================
  195.  
  196. SPRINTF
  197.  
  198. Formatierte Ausgabe in den Stringpuffer "s".
  199.  
  200. Übersicht
  201. #include <stormamiga.h>
  202.  
  203. r = SPRINTF(s,format,...);
  204.  
  205. long r;
  206. char *s;
  207. const char *format;
  208.  
  209. Standard
  210. (noch) keiner (Eigenentwicklung)
  211.  
  212. Erklärung
  213. Formatierte Ausgabe in den  Stringpuffer  "s". Der Formatstring
  214. "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich
  215. angegebene Parameter.
  216.  
  217. "SPRINTF" verwendet den Befehl "RawDoFmt" der "exec.library"
  218. und ist dadurch auch sehr klein.
  219.  
  220. Rückgabe
  221. Die Anzahl der ausgegebenen Zeichen.
  222.  
  223. ============================================================================
  224.  
  225. VSPRINTF
  226.  
  227. Formatierte Ausgabe in den Stringpuffer "s".
  228.  
  229. Übersicht
  230. #include <stormamiga.h>
  231.  
  232. r = VSPRINTF(s,format,vl);
  233.  
  234. long r;
  235. char *s;
  236. const char *format;
  237. va_list vl;
  238.  
  239. Standard
  240. (noch) keiner (Eigenentwicklung)
  241.  
  242. Erklärung
  243. Formatierte Ausgabe in den  Stringpuffer  "s". Der Formatstring
  244. "format" beschreibt das Ausgabeformat. Danach folgt eine
  245.  Parameterliste  "vl".
  246.  
  247. "VSPRINTF" verwendet den Befehl "RawDoFmt" der "exec.library"
  248. und ist dadurch auch sehr klein.
  249.  
  250. Rückgabe
  251. Die Anzahl der ausgegebenen Zeichen.
  252.  
  253. ============================================================================
  254.  
  255. printf_
  256.  
  257. Formatierte Ausgabe in die Standardausgabe "stdout".
  258. Funktionsreduzierte Version von "printf".
  259.  
  260. Übersicht
  261. #include <stormamiga.h>
  262.  
  263. r = printf_(format,...);
  264.  
  265. int r;
  266. const char *format;
  267.  
  268. Standard
  269. (noch) keiner (Eigenentwicklung)
  270.  
  271. Erklärung
  272. Formatierte Ausgabe in die Standardausgabe "stdout". Der
  273.  Ausgabeformatstring_  "format" beschreibt das Ausgabe-
  274. format. Danach folgen zusätzlich angegebene Parameter.
  275.  
  276. Rückgabe
  277. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  278. eine negative Zahl.
  279.  
  280. ============================================================================
  281.  
  282. printf__
  283.  
  284. Formatierte Ausgabe in die Standardausgabe "stdout".
  285. Funktionsreduzierte Version von "printf_".
  286.  
  287. Übersicht
  288. #include <stormamiga.h>
  289.  
  290. r = printf__(format,...);
  291.  
  292. int r;
  293. const char *format;
  294.  
  295. Standard
  296. (noch) keiner (Eigenentwicklung)
  297.  
  298. Erklärung
  299. Formatierte Ausgabe in die Standardausgabe "stdout". Der
  300.  Ausgabeformatstring__  "format" beschreibt das Ausgabe-
  301. format. Danach folgen zusätzlich angegebene Parameter.
  302.  
  303. Rückgabe
  304. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  305. eine negative Zahl.
  306.  
  307.  
  308. ============================================================================
  309.  
  310. fprintf_
  311.  
  312. Formatierte Ausgabe in die Datei "f".
  313. Funktionsreduzierte Version von "fprintf".
  314.  
  315. Übersicht
  316. #include <stormamiga.h>
  317.  
  318. r = fprintf_(f,format,...);
  319.  
  320. int r;
  321. FILE *f;
  322. const char *format;
  323.  
  324. Standard
  325. (noch) keiner (Eigenentwicklung)
  326.  
  327. Erklärung
  328. Formatierte Ausgabe in die Datei "f". Der  Ausgabeformatstring_ 
  329. "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich
  330. angegebene Parameter.
  331.  
  332. Rückgabe
  333. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  334. eine negative Zahl.
  335.  
  336. ============================================================================
  337.  
  338. fprintf__
  339.  
  340. Formatierte Ausgabe in die Datei "f".
  341. Funktionsreduzierte Version von "fprintf_".
  342.  
  343. Übersicht
  344. #include <stormamiga.h>
  345.  
  346. r = fprintf__(f,format,...);
  347.  
  348. int r;
  349. FILE *f;
  350. const char *format;
  351.  
  352. Standard
  353. (noch) keiner (Eigenentwicklung)
  354.  
  355. Erklärung
  356. Formatierte Ausgabe in die Datei "f". Der  Ausgabeformatstring__ 
  357. "format" beschreibt das Ausgabeformat. Danach folgen zusätzlich
  358. angegebene Parameter.
  359.  
  360. Rückgabe
  361. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  362. eine negative Zahl.
  363.  
  364. ============================================================================
  365.  
  366. sprintf_
  367.  
  368. Formatierte Ausgabe in den Stringpuffer "s".
  369. Funktionsreduzierte Version von "sprintf".
  370.  
  371. Übersicht
  372. #include <stormamiga.h>
  373.  
  374. r = sprintf_(s,format,...);
  375.  
  376. int r;
  377. char *s;
  378. const char *format;
  379.  
  380. Standard
  381. (noch) keiner (Eigenentwicklung)
  382.  
  383. Erklärung
  384. Formatierte Ausgabe in den  Stringpuffer  "s". Der
  385.  Ausgabeformatstring_  "format" beschreibt das Ausgabe-
  386. format. Danach folgen zusätzlich angegebene Parameter.
  387.  
  388. Rückgabe
  389. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  390. eine negative Zahl.
  391.  
  392. ============================================================================
  393.  
  394. sprintf__
  395.  
  396. Formatierte Ausgabe in den Stringpuffer "s".
  397. Funktionsreduzierte Version von "sprintf_".
  398.  
  399. Übersicht
  400. #include <stormamiga.h>
  401.  
  402. r = sprintf__(s,format,...);
  403.  
  404. int r;
  405. char *s;
  406. const char *format;
  407.  
  408. Standard
  409. (noch) keiner (Eigenentwicklung)
  410.  
  411. Erklärung
  412. Formatierte Ausgabe in den  Stringpuffer  "s". Der
  413.  Ausgabeformatstring__  "format" beschreibt das Ausgabe-
  414. format. Danach folgen zusätzlich angegebene Parameter.
  415.  
  416. Rückgabe
  417. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  418. eine negative Zahl.
  419.  
  420. ============================================================================
  421.  
  422. vprintf_
  423.  
  424. Formatierte Ausgabe in die Standardausgabe "stdout".
  425. Funktionsreduzierte Version von "vprintf".
  426.  
  427. Übersicht
  428. #include <stormamiga.h>
  429.  
  430. r = vprintf_(format,vl);
  431.  
  432. int r;
  433. const char *format;
  434. va_list vl;
  435.  
  436. Standard
  437. (noch) keiner (Eigenentwicklung)
  438.  
  439. Erklärung
  440. Formatierte Ausgabe in die Standardausgabe "stdout". Der
  441.  Ausgabeformatstring_  "format" beschreibt das Ausgabe-
  442. format. Danach folgt eine  Parameterliste  "vl".
  443.  
  444. Rückgabe
  445. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  446. eine negative Zahl.
  447.  
  448. ============================================================================
  449.  
  450. vprintf__
  451.  
  452. Formatierte Ausgabe in die Standardausgabe "stdout".
  453. Funktionsreduzierte Version von "vprintf_".
  454.  
  455. Übersicht
  456. #include <stormamiga.h>
  457.  
  458. r = vprintf__(format,vl);
  459.  
  460. int r;
  461. const char *format;
  462. va_list vl;
  463.  
  464. Standard
  465. (noch) keiner (Eigenentwicklung)
  466.  
  467. Erklärung
  468. Formatierte Ausgabe in die Standardausgabe "stdout". Der
  469.  Ausgabeformatstring__  "format" beschreibt das Ausgabe-
  470. format. Danach folgt eine  Parameterliste  "vl".
  471.  
  472. Rückgabe
  473. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  474. eine negative Zahl.
  475.  
  476. ============================================================================
  477.  
  478. vfprintf_
  479.  
  480. Formatierte Ausgabe in die Datei "f".
  481. Funktionsreduzierte Version von "vfprintf".
  482.  
  483. Übersicht
  484. #include <stormamiga.h>
  485.  
  486. r = vfprintf_(f,format,vl);
  487.  
  488. int r;
  489. FILE *f;
  490. const char *format;
  491. va_list vl;
  492.  
  493. Standard
  494. (noch) keiner (Eigenentwicklung)
  495.  
  496. Erklärung
  497. Formatierte Ausgabe in die Datei "f". Der
  498.  Ausgabeformatstring_  "format" beschreibt
  499. das Ausgabeformat. Danach folgt eine
  500.  Parameterliste  "vl".
  501.  
  502. Rückgabe
  503. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  504. eine negative Zahl.
  505.  
  506. ============================================================================
  507.  
  508. vfprintf__
  509.  
  510. Formatierte Ausgabe in die Datei "f".
  511. Funktionsreduzierte Version von "vfprintf_".
  512.  
  513. Übersicht
  514. #include <stormamiga.h>
  515.  
  516. r = vfprintf__(f,format,vl);
  517.  
  518. int r;
  519. FILE *f;
  520. const char *format;
  521. va_list vl;
  522.  
  523. Standard
  524. (noch) keiner (Eigenentwicklung)
  525.  
  526. Erklärung
  527. Formatierte Ausgabe in die Datei "f". Der
  528.  Ausgabeformatstring__  "format" beschreibt
  529. das Ausgabeformat. Danach folgt eine
  530.  Parameterliste  "vl".
  531.  
  532. Rückgabe
  533. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  534. eine negative Zahl.
  535.  
  536. ============================================================================
  537.  
  538. vsprintf_
  539.  
  540. Formatierte Ausgabe in den Stringpuffer "s".
  541. Funktionsreduzierte Version von "vsprintf".
  542.  
  543. Übersicht
  544. #include <stormamiga.h>
  545.  
  546. r = vsprintf_(s,format,vl);
  547.  
  548. int r;
  549. char *s;
  550. const char *format;
  551. va_list vl;
  552.  
  553. Standard
  554. (noch) keiner (Eigenentwicklung)
  555.  
  556. Erklärung
  557. Formatierte Ausgabe in den  Stringpuffer  "s". Der
  558.  Ausgabeformatstring_  "format" beschreibt das
  559. Ausgabeformat. Danach folgt eine  Parameterliste  "vl".
  560.  
  561. Rückgabe
  562. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  563. eine negative Zahl.
  564.  
  565. ============================================================================
  566.  
  567. vsprintf__
  568.  
  569. Formatierte Ausgabe in den Stringpuffer "s".
  570. Funktionsreduzierte Version von "vsprintf_".
  571.  
  572. Übersicht
  573. #include <stormamiga.h>
  574.  
  575. r = vsprintf__(s,format,vl);
  576.  
  577. int r;
  578. char *s;
  579. const char *format;
  580. va_list vl;
  581.  
  582. Standard
  583. (noch) keiner (Eigenentwicklung)
  584.  
  585. Erklärung
  586. Formatierte Ausgabe in den  Stringpuffer  "s". Der
  587.  Ausgabeformatstring__  "format" beschreibt das
  588. Ausgabeformat. Danach folgt eine  Parameterliste  "vl".
  589.  
  590. Rückgabe
  591. Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall
  592. eine negative Zahl.
  593.  
  594. ============================================================================
  595.  
  596. scanf_
  597.  
  598. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  599. Funktionsreduzierte Version von "scanf".
  600.  
  601. Übersicht
  602. #include <stormamiga.h>
  603.  
  604. r = scanf_(format,...);
  605.  
  606. int r;
  607. const char *format;
  608.  
  609. Standard
  610. (noch) keiner (Eigenentwicklung)
  611.  
  612. Erklärung
  613. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  614. Der  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  615. Danach folgen zusätzlich angegebene Parameter.
  616.  
  617. Rückgabe
  618. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  619. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  620.  
  621. ============================================================================
  622.  
  623. scanf__
  624.  
  625. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  626. Funktionsreduzierte Version von "scanf_".
  627.  
  628. Übersicht
  629. #include <stormamiga.h>
  630.  
  631. r = scanf__(format,...);
  632.  
  633. int r;
  634. const char *format;
  635.  
  636. Standard
  637. (noch) keiner (Eigenentwicklung)
  638.  
  639. Erklärung
  640. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  641. Der  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  642. Danach folgen zusätzlich angegebene Parameter.
  643.  
  644. Rückgabe
  645. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  646. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  647.  
  648. ============================================================================
  649.  
  650. fscanf_
  651.  
  652. Einlesen einer formatierten Eingabe aus der Datei "f".
  653. Funktionsreduzierte Version von "fscanf".
  654.  
  655. Übersicht
  656. #include <stormamiga.h>
  657.  
  658. r = fscanf_(f,format,...);
  659.  
  660. int r;
  661. FILE *f;
  662. const char *format;
  663.  
  664. Standard
  665. (noch) keiner (Eigenentwicklung)
  666.  
  667. Erklärung
  668. Einlesen einer formatierten Eingabe aus der Datei "f". Der
  669.  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  670. Danach folgen zusätzlich angegebene Parameter.
  671.  
  672. Rückgabe
  673. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  674. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  675.  
  676. ============================================================================
  677.  
  678. fscanf__
  679.  
  680. Einlesen einer formatierten Eingabe aus der Datei "f".
  681. Funktionsreduzierte Version von "fscanf_".
  682.  
  683. Übersicht
  684. #include <stormamiga.h>
  685.  
  686. r = fscanf__(f,format,...);
  687.  
  688. int r;
  689. FILE *f;
  690. const char *format;
  691.  
  692. Standard
  693. (noch) keiner (Eigenentwicklung)
  694.  
  695. Erklärung
  696. Einlesen einer formatierten Eingabe aus der Datei "f". Der
  697.  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  698. Danach folgen zusätzlich angegebene Parameter.
  699.  
  700. Rückgabe
  701. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  702. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  703.  
  704. ============================================================================
  705.  
  706. sscanf_
  707.  
  708. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".
  709. Funktionsreduzierte Version von "sscanf".
  710.  
  711. Übersicht
  712. #include <stormamiga.h>
  713.  
  714. r = sscanf_(s,format,...);
  715.  
  716. int r;
  717. char *s;
  718. const char *format;
  719.  
  720. Standard
  721. (noch) keiner (Eigenentwicklung)
  722.  
  723. Erklärung
  724. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der
  725.  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  726. Danach folgen zusätzlich angegebene Parameter.
  727.  
  728. Rückgabe
  729. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  730. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  731.  
  732. ============================================================================
  733.  
  734. sscanf__
  735.  
  736. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".
  737. Funktionsreduzierte Version von "sscanf_".
  738.  
  739. Übersicht
  740. #include <stormamiga.h>
  741.  
  742. r = sscanf__(s,format,...);
  743.  
  744. int r;
  745. char *s;
  746. const char *format;
  747.  
  748. Standard
  749. (noch) keiner (Eigenentwicklung)
  750.  
  751. Erklärung
  752. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der
  753.  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  754. Danach folgen zusätzlich angegebene Parameter.
  755.  
  756. Rückgabe
  757. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  758. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  759.  
  760. ============================================================================
  761.  
  762. vscanf
  763.  
  764. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  765.  
  766. Übersicht
  767. #include <stormamiga.h>
  768.  
  769. r = vscanf(format,vl);
  770.  
  771. int r;
  772. const char *format;
  773. va_list vl;
  774.  
  775. Standard
  776. (noch) keiner (Eigenentwicklung)
  777.  
  778. Erklärung
  779. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  780. Der  Eingabeformatstring  "format" beschreibt das Eingabeformat.
  781. Danach folgt eine  Parameterliste  "vl".
  782.  
  783. Rückgabe
  784. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  785. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  786.  
  787. ============================================================================
  788.  
  789. vscanf_
  790.  
  791. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  792. Funktionsreduzierte Version von "scanf".
  793.  
  794. Übersicht
  795. #include <stormamiga.h>
  796.  
  797. r = vscanf_(format,vl);
  798.  
  799. int r;
  800. const char *format;
  801. va_list vl;
  802.  
  803. Standard
  804. (noch) keiner (Eigenentwicklung)
  805.  
  806. Erklärung
  807. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  808. Der  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  809. Danach folgt eine  Parameterliste  "vl".
  810.  
  811. Rückgabe
  812. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  813. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  814.  
  815. ============================================================================
  816.  
  817. vscanf__
  818.  
  819. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  820. Funktionsreduzierte Version von "scanf_".
  821.  
  822. Übersicht
  823. #include <stormamiga.h>
  824.  
  825. r = vscanf__(format,vl);
  826.  
  827. int r;
  828. const char *format;
  829. va_list vl;
  830.  
  831. Standard
  832. (noch) keiner (Eigenentwicklung)
  833.  
  834. Erklärung
  835. Einlesen einer formatierten Eingabe aus der Standardeingabe "stdin".
  836. Der  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  837. Danach folgt eine  Parameterliste  "vl".
  838.  
  839. Rückgabe
  840. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  841. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  842.  
  843. ============================================================================
  844.  
  845. vfscanf
  846.  
  847. Einlesen einer formatierten Eingabe aus der Datei "f".
  848.  
  849. Übersicht
  850. #include <stormamiga.h>
  851.  
  852. r = vfscanf(f,format,vl);
  853.  
  854. int r;
  855. FILE *f;
  856. const char *format;
  857. va_list vl;
  858.  
  859. Standard
  860. (noch) keiner (Eigenentwicklung)
  861.  
  862. Erklärung
  863. Einlesen einer formatierten Eingabe aus der Datei "f". Der
  864.  Eingabeformatstring  "format" beschreibt das Eingabeformat.
  865. Danach folgt eine  Parameterliste  "vl".
  866.  
  867. Rückgabe
  868. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  869. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  870.  
  871. ============================================================================
  872.  
  873. vfscanf_
  874.  
  875. Einlesen einer formatierten Eingabe aus der Datei "f".
  876. Funktionsreduzierte Version von "vfscanf".
  877.  
  878. Übersicht
  879. #include <stormamiga.h>
  880.  
  881. r = vfscanf_(f,format,vl);
  882.  
  883. int r;
  884. FILE *f;
  885. const char *format;
  886. va_list vl;
  887.  
  888. Standard
  889. (noch) keiner (Eigenentwicklung)
  890.  
  891. Erklärung
  892. Einlesen einer formatierten Eingabe aus der Datei "f". Der
  893.  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  894. Danach folgt eine  Parameterliste  "vl".
  895.  
  896. Rückgabe
  897. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  898. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  899.  
  900. ============================================================================
  901.  
  902. vfscanf__
  903.  
  904. Einlesen einer formatierten Eingabe aus der Datei "f".
  905. Funktionsreduzierte Version von "vfscanf_".
  906.  
  907. Übersicht
  908. #include <stormamiga.h>
  909.  
  910. r = vfscanf__(f,format,vl);
  911.  
  912. int r;
  913. FILE *f;
  914. const char *format;
  915. va_list vl;
  916.  
  917. Standard
  918. (noch) keiner (Eigenentwicklung)
  919.  
  920. Erklärung
  921. Einlesen einer formatierten Eingabe aus der Datei "f". Der
  922.  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  923. Danach folgt eine  Parameterliste  "vl".
  924.  
  925. Rückgabe
  926. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  927. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  928.  
  929. ============================================================================
  930.  
  931. vsscanf
  932.  
  933. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".
  934.  
  935. Übersicht
  936. #include <stormamiga.h>
  937.  
  938. r = vsscanf(s,format,vl);
  939.  
  940. int r;
  941. char *s;
  942. const char *format;
  943. va_list vl;
  944.  
  945. Standard
  946. (noch) keiner (Eigenentwicklung)
  947.  
  948. Erklärung
  949. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der
  950.  Eingabeformatstring  "format" beschreibt das Eingabeformat.
  951. Danach folgt eine  Parameterliste  "vl".
  952.  
  953. Rückgabe
  954. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  955. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  956.  
  957. ============================================================================
  958.  
  959. vsscanf_
  960.  
  961. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".
  962. Funktionsreduzierte Version von "vsscanf".
  963.  
  964. Übersicht
  965. #include <stormamiga.h>
  966.  
  967. r = vsscanf_(s,format,vl);
  968.  
  969. int r;
  970. char *s;
  971. const char *format;
  972. va_list vl;
  973.  
  974. Standard
  975. (noch) keiner (Eigenentwicklung)
  976.  
  977. Erklärung
  978. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der
  979.  Eingabeformatstring_  "format" beschreibt das Eingabeformat.
  980. Danach folgt eine  Parameterliste  "vl".
  981.  
  982. Rückgabe
  983. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  984. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  985.  
  986. ============================================================================
  987.  
  988. vsscanf__
  989.  
  990. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s".
  991. Funktionsreduzierte Version von "vsscanf_".
  992.  
  993. Übersicht
  994. #include <stormamiga.h>
  995.  
  996. r = vsscanf__(s,format,vl);
  997.  
  998. int r;
  999. char *s;
  1000. const char *format;
  1001. va_list vl;
  1002.  
  1003. Standard
  1004. (noch) keiner (Eigenentwicklung)
  1005.  
  1006. Erklärung
  1007. Einlesen einer formatierten Eingabe aus dem Stringpuffer "s". Der
  1008.  Eingabeformatstring__  "format" beschreibt das Eingabeformat.
  1009. Danach folgt eine  Parameterliste  "vl".
  1010.  
  1011. Rückgabe
  1012. Die Anzahl der eingelesenen Zeichen oder im Fehlerfall einen Rück-
  1013. gabewert der kleiner als die Anzahl der eingelesenen Zeichen ist.
  1014.  
  1015. ============================================================================
  1016.  
  1017. strcoll
  1018.  
  1019. vergleichen zweier Strings unter Beachtung der aktuellen Sprache
  1020.  
  1021. Übersicht
  1022. #include <stormamiga.h>
  1023.  
  1024. r = strcoll(s1,s2);
  1025.  
  1026. int r;
  1027. const char *s1;
  1028. const char *s2;
  1029.  
  1030. Standard
  1031. ANSI C3.159-1989 ("ANSI C")
  1032.  
  1033. Erklärung
  1034. Vergleicht die Strings "s1" und "s2" Zeichen für Zeichen. Wenn die
  1035. "locale.library" geöffnet ist, wird der Befehl "StrnCmp" ausgeführt.
  1036. Wenn sie nicht geöffnet ist, wird der Befehl "strcmp" ausgeführt.
  1037. Dabei wird die aktuelle Sprache nicht berücksichtigt.
  1038.  
  1039. Rückgabe
  1040. <0 wenn s1 < s2
  1041. =0 wenn s1 = s2
  1042. >0 wenn s1 > s2
  1043.  
  1044. ============================================================================
  1045.  
  1046. strxfrm
  1047.  
  1048. transformieren eines Strings unter Beachtung der aktuellen Sprache
  1049.  
  1050. Übersicht
  1051. #include <stormamiga.h>
  1052.  
  1053. r = strxfrm(dest,source,n);
  1054.  
  1055. int r;
  1056. char *dest;
  1057. const char *source;
  1058. size_t n;
  1059.  
  1060. Standard
  1061. ANSI C3.159-1989 ("ANSI C")
  1062.  
  1063. Erklärung
  1064. Transformiert (kopiert) maximal "n" Bytes vom String "source" nach
  1065. "dest". Wenn die "locale.library" geöffnet ist, wird der Befehl
  1066. "StrConvert" ausgeführt. Wenn sie nicht geöffnet ist, wird der
  1067. Befehl "strncpy" ausgeführt. Dabei wird der String "source", ohne
  1068. Berücksichtigung der aktuellen Sprache, nur kopiert .
  1069.  
  1070. Rückgabe
  1071. Die Länge des transformierten Strings "source" ohne Nullzeichen.
  1072.  
  1073. ============================================================================
  1074.  
  1075. bcmp
  1076.  
  1077. vergleichen zweier Speicherbereiche
  1078.  
  1079. Übersicht
  1080. #include <stormamiga.h>
  1081.  
  1082. r = bcmp(b1,b2,n);
  1083.  
  1084. int r;
  1085. const void *b1;
  1086. const void *b2;
  1087. size_t n;
  1088.  
  1089. Standard
  1090. (noch) keiner (4.2BSD)
  1091.  
  1092. Erklärung
  1093. Vergleicht die Speicherbereiche "b1" und "b2" Byte für Byte auf
  1094. maximal "n" Bytes Länge. Die Speicherbereiche dürfen sich über-
  1095. schneiden.
  1096.  
  1097. Rückgabe
  1098. Wenn beide Byte-Strings gleich sind, ist der Rückgabewert 0, sonst
  1099. ist er ungleich 0.
  1100.  
  1101. ============================================================================
  1102.  
  1103. bcopy
  1104.  
  1105. Speicher kopieren
  1106.  
  1107. Übersicht
  1108. #include <stormamiga.h>
  1109.  
  1110. r = bcopy(source,dest,n);
  1111.  
  1112. void r;
  1113. const void *source;
  1114. void *dest;
  1115. size_t n;
  1116.  
  1117. Standard
  1118. (noch) keiner (4.2BSD)
  1119.  
  1120. Erklärung
  1121. Kopiert "n" Bytes vom Speicherbereich "source" nach "dest". Die
  1122. Speicherbereiche dürfen sich überschneiden. Wenn "n" 0 ist, wird
  1123. nichts kopiert.
  1124.  
  1125. Rückgabe
  1126.  
  1127.  
  1128. ============================================================================
  1129.  
  1130. bzero
  1131.  
  1132. schreibt NULL-Bytes in einen Speicherbereich
  1133.  
  1134. Übersicht
  1135. #include <stormamiga.h>
  1136.  
  1137. r = bzero(b,n);
  1138.  
  1139. void r;
  1140. void b;
  1141. size_t n;
  1142.  
  1143. Standard
  1144. (noch) keiner (4.3BSD)
  1145.  
  1146. Erklärung
  1147. Schreibt "n" NULL-Bytes in den Speicherbereich "b".
  1148.  
  1149. Rückgabe
  1150.  
  1151.  
  1152. ============================================================================
  1153.  
  1154. ffs
  1155.  
  1156. Findet das erste gesetzte Bit in einem Bit-String
  1157.  
  1158. Übersicht
  1159. #include <stormamiga.h>
  1160.  
  1161. r = ffs(value);
  1162.  
  1163. int r;
  1164. int value;
  1165.  
  1166. Standard
  1167. (noch) keiner (4.3BSD)
  1168.  
  1169. Erklärung
  1170. Findet das erste gesetzte Bit in dem Bit-String "value" und gibt
  1171. den Index davon zurück.
  1172.  
  1173. Rückgabe
  1174. Index des Bit-String "value"
  1175.  
  1176. ============================================================================
  1177.  
  1178. index
  1179.  
  1180. Sucht das erste Vorkommen eines Zeichens in einem String
  1181.  
  1182. Übersicht
  1183. #include <stormamiga.h>
  1184.  
  1185. r = index(s,c);
  1186.  
  1187. char *r;
  1188. const char *s;
  1189. int c;
  1190.  
  1191. Standard
  1192. (noch) keiner (Version 6 AT&T UNIX)
  1193.  
  1194. Erklärung
  1195. Sucht das erste Vorkommen des Zeichens "c" in dem String "s"
  1196. und gibt einen Zeiger auf das erste gefundene Zeichen "c"
  1197. zurück. Wenn das Zeichen "c" nicht gefunden wird, wird 0
  1198. zurückgegeben.
  1199.  
  1200. Rückgabe
  1201. Ein Zeiger auf das erste gefundene Zeichen "c" oder 0.
  1202.  
  1203. ============================================================================
  1204.  
  1205. rindex
  1206.  
  1207. Sucht das letzte Vorkommen eines Zeichens in einem String
  1208.  
  1209. Übersicht
  1210. #include <stormamiga.h>
  1211.  
  1212. r = rindex(s,c);
  1213.  
  1214. char *r;
  1215. const char *s;
  1216. int c;
  1217.  
  1218. Standard
  1219. (noch) keiner (Version 6 AT&T UNIX)
  1220.  
  1221. Erklärung
  1222. Sucht das letzte Vorkommen des Zeichens "c" in dem String "s"
  1223. und gibt einen Zeiger auf das letzte gefundene Zeichen "c"
  1224. zurück. Wenn das Zeichen "c" nicht gefunden wird, wird 0
  1225. zurückgegeben.
  1226.  
  1227. Rückgabe
  1228. Ein Zeiger auf das letzte gefundene Zeichen "c" oder 0.
  1229.  
  1230. ============================================================================
  1231.  
  1232. memccpy
  1233.  
  1234. Speicher kopieren
  1235.  
  1236. Übersicht
  1237. #include <stormamiga.h>
  1238.  
  1239. r = memccpy(dest,source,c,n);
  1240.  
  1241. void *r;
  1242. void *dest;
  1243. const void *source;
  1244. int c;
  1245. size_t n;
  1246.  
  1247. Standard
  1248. (noch) keiner (4.3BSD)
  1249.  
  1250. Erklärung
  1251. Die Funktion kopiert den Speicherbereich "source" in den Speicher-
  1252. bereich "dest". Wenn das Zeichen "c" im Speicherbereich "source"
  1253. vorkommt, wird der Kopiervorgang an dieser Stelle gestoppt und ein
  1254. Zeiger auf das Byte hinter der Kopie des Zeichens "c" im Speicher-
  1255. bereich "dest" zurückgegeben. Ansonsten werden "n" Bytes kopiert
  1256. und 0 zurückgegeben.
  1257.  
  1258. Rückgabe
  1259. Ein Zeiger auf das Byte hinter der Kopie des Zeichens "c" im
  1260. Speicherbereich "dest" oder 0.
  1261.  
  1262. ============================================================================
  1263.  
  1264. strsep
  1265.  
  1266. trennt Strings
  1267.  
  1268. Übersicht
  1269. #include <stormamiga.h>
  1270.  
  1271. r = strsep(s1,s2);
  1272.  
  1273. char *r;
  1274. char **s1;
  1275. char *s2;
  1276.  
  1277. Standard
  1278. (noch) keiner
  1279.  
  1280. Erklärung
  1281. Die Funktion findet im String "*s1" (mit abschließendem Nullzeichen)
  1282. das erste Vorkommen eines Zeichens aus dem String "s2", ersetzt dieses
  1283. durch ein Nullzeichen  und verzeichnet die Stelle des nächsten Zeichens
  1284. im String "*s1". Es wird der Originalwert des Strings "*s1" zurückgege-
  1285. ben. Wenn kein Zeichens aus dem String "s2" gefunden wird, wird 0 zurück-
  1286. gegeben.
  1287.  
  1288. Rückgabe
  1289. Der Originalwert des Strings "*s1" oder 0.
  1290.  
  1291. ============================================================================
  1292.  
  1293. swab
  1294.  
  1295. vertauschen angrenzender Bytes
  1296.  
  1297. Übersicht
  1298. #include <stormamiga.h>
  1299.  
  1300. r = swab(source,dest,n);
  1301.  
  1302. void r;
  1303. const void *source;
  1304. void *dest;
  1305. size_t n;
  1306.  
  1307. Standard
  1308. (noch) keiner (Version 7 AT&T UNIX)
  1309.  
  1310. Erklärung
  1311. Kopiert "n" Bytes von "source" nach "dest" und vertauscht die
  1312. angrenzenden Bytes. "n" muß eine gerade Zahl sein.
  1313.  
  1314. Rückgabe
  1315.  
  1316.  
  1317. ============================================================================
  1318.  
  1319. muls
  1320.  
  1321. signed 32 Bit mal 32 Bit Multiplikation mit 32 Bit Ergebnis
  1322.  
  1323. Übersicht
  1324. #include <stormamiga.h>
  1325.  
  1326. r = muls(arg1,arg2);
  1327.  
  1328. LONG r;
  1329. LONG arg1;
  1330. LONG arg2;
  1331.  
  1332. Standard
  1333. (noch) keiner (Eigenentwicklung)
  1334.  
  1335. Erklärung
  1336. Der Befehl "muls" multipliziert "arg1" mit "arg2" und ermittelt
  1337. das Ergebnis "r".
  1338. Der Befehl "muls" ist ein sehr schneller und sehr kleiner (6 Byte)
  1339. Ersatz für den Befehl "SMult32" der "utility.library". Da die Funk-
  1340. tion und der Aufruf beider Befehle identisch ist, kann "SMult32"
  1341. einfach durch "muls" ersetzt werden.
  1342.  
  1343. Rückgabe
  1344. signed 32 Bit Ergebnis "r"
  1345.  
  1346. ============================================================================
  1347.  
  1348. mulu
  1349.  
  1350. unsigned 32 Bit mal 32 Bit Multiplikation mit 32 Bit Ergebnis
  1351.  
  1352. Übersicht
  1353. #include <stormamiga.h>
  1354.  
  1355. r = mulu(arg1,arg2);
  1356.  
  1357. ULONG r;
  1358. ULONG arg1;
  1359. ULONG arg2;
  1360.  
  1361. Standard
  1362. (noch) keiner (Eigenentwicklung)
  1363.  
  1364. Erklärung
  1365. Der Befehl "mulu" multipliziert "arg1" mit "arg2" und ermittelt
  1366. das Ergebnis "r".
  1367. Der Befehl "mulu" ist ein sehr schneller und sehr kleiner (6 Byte)
  1368. Ersatz für den Befehl "UMult32" der "utility.library". Da die Funk-
  1369. tion und der Aufruf beider Befehle identisch ist, kann "UMult32"
  1370. einfach durch "mulu" ersetzt werden.
  1371.  
  1372. Rückgabe
  1373. unsigned 32 Bit Ergebnis "r"
  1374.  
  1375. ============================================================================
  1376.  
  1377. divsl
  1378.  
  1379. signed 32 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest
  1380.  
  1381. Übersicht
  1382. #include <stormamiga.h>
  1383.  
  1384. quotient:remainder = divsl(dividend,divisor);
  1385.  
  1386. LONG quotient;
  1387. LONG remainder
  1388. LONG dividend;
  1389. LONG divisor;
  1390.  
  1391. Standard
  1392. (noch) keiner (Eigenentwicklung)
  1393.  
  1394. Erklärung
  1395. Der Befehl "divsl" teilt den Dividenden "dividend" durch den
  1396. Divisor "divisor" und ermittelt den Quotient "quotient" und den
  1397. Rest "remainder".
  1398. Der Befehl "divsl" ist ein sehr schneller und sehr kleiner
  1399. (6 Byte) Ersatz für den Befehl "SDivMod32" der "utility.library".
  1400. Da die Funktion und der Aufruf beider Befehle identisch ist, kann
  1401. "SDivMod32" einfach durch "divsl" ersetzt werden.
  1402.  
  1403. Rückgabe
  1404. signed 32 Bit Quotient "quotient"
  1405. signed 32 Bit Rest "remainder"
  1406.  
  1407. ============================================================================
  1408.  
  1409. divul
  1410.  
  1411. unsigned 32 Bit durch 32 Bit Division mit 32 Bit Quotient und Rest
  1412.  
  1413. Übersicht
  1414. #include <stormamiga.h>
  1415.  
  1416. quotient:remainder = divul(dividend,divisor);
  1417.  
  1418. ULONG quotient;
  1419. ULONG remainder
  1420. ULONG dividend;
  1421. ULONG divisor;
  1422.  
  1423. Standard
  1424. (noch) keiner (Eigenentwicklung)
  1425.  
  1426. Erklärung
  1427. Der Befehl "divul" teilt den Dividenden "dividend" durch den
  1428. Divisor "divisor" und ermittelt den Quotient "quotient" und den
  1429. Rest "remainder".
  1430. Der Befehl "divul" ist ein sehr schneller und sehr kleiner
  1431. (6 Byte) Ersatz für den Befehl "UDivMod32" der "utility.library".
  1432. Da die Funktion und der Aufruf beider Befehle identisch ist, kann
  1433. "UDivMod32" einfach durch "divul" ersetzt werden.
  1434.  
  1435. Rückgabe
  1436. unsigned 32 Bit Quotient "quotient"
  1437. unsigned 32 Bit Rest "remainder"
  1438.  
  1439. ============================================================================
  1440.  
  1441. muls64
  1442.  
  1443. signed 32 Bit mal 32 Bit Multiplikation mit 64 Bit Ergebnis
  1444.  
  1445. Übersicht
  1446. #include <stormamiga.h>
  1447.  
  1448. r = muls64(arg1,arg2);
  1449.  
  1450. LONG r;
  1451. LONG arg1;
  1452. LONG arg2;
  1453.  
  1454. Standard
  1455. (noch) keiner (Eigenentwicklung)
  1456.  
  1457. Erklärung
  1458. Der Befehl "muls64" multipliziert "arg1" mit "arg2" und ermittelt
  1459. das Ergebnis "r".
  1460. Der Befehl "muls64" ist ein sehr schneller und sehr kleiner (6 Byte)
  1461. Ersatz für den Befehl "SMult64" der "utility.library". Da die Funk-
  1462. tion und der Aufruf beider Befehle identisch ist, kann "SMult64"
  1463. einfach durch "muls64" ersetzt werden.
  1464. Im Gegensatz zu "SMult64", benötigt "muls64" nicht AmigaOS 3.x,
  1465. sondern ist bereits ab AmigaOS 2.x lauffähig.
  1466.  
  1467. Rückgabe
  1468. signed 64 Bit Ergebnis "r"
  1469.  
  1470. ============================================================================
  1471.  
  1472. mulu64
  1473.  
  1474. unsigned 32 Bit mal 32 Bit Multiplikation mit 64 Bit Ergebnis
  1475.  
  1476. Übersicht
  1477. #include <stormamiga.h>
  1478.  
  1479. r = mulu64(arg1,arg2);
  1480.  
  1481. ULONG r;
  1482. ULONG arg1;
  1483. ULONG arg2;
  1484.  
  1485. Standard
  1486. (noch) keiner (Eigenentwicklung)
  1487.  
  1488. Erklärung
  1489. Der Befehl "mulu64" multipliziert "arg1" mit "arg2" und ermittelt
  1490. das Ergebnis "r".
  1491. Der Befehl "mulu64" ist ein sehr schneller und sehr kleiner (6 Byte)
  1492. Ersatz für den Befehl "UMult64" der "utility.library". Da die Funk-
  1493. tion und der Aufruf beider Befehle identisch ist, kann "UMult64"
  1494. einfach durch "mulu64" ersetzt werden.
  1495. Im Gegensatz zu "UMult64", benötigt "mulu64" nicht AmigaOS 3.x,
  1496. sondern ist bereits ab AmigaOS 2.x lauffähig.
  1497.  
  1498. Rückgabe
  1499. unsigned 64 Bit Ergebnis "r"
  1500.  
  1501. ============================================================================
  1502.  
  1503. Der Stringpuffer "s"
  1504.  
  1505. Der Stringpuffer "s" muß mindestens so groß sein, daß die
  1506. Ausgabe mit abschließenden Nullzeichen hineinpaßt.
  1507. Die Funktion kann nicht feststellen ob der Stringpuffer groß
  1508. genug ist.
  1509.  
  1510. ============================================================================
  1511.  
  1512. Die Parameterliste "vl"
  1513.  
  1514. Die Parameterliste "vl" muß vor dem Aufruf mit va_start initia-
  1515. lisiert werden und nach dem Aufruf mit va_end abgeschlossen wer-
  1516. den.
  1517.  
  1518. ============================================================================
  1519.  
  1520. Der Ausgabeformatstring_ "format" zur formatierten Ausgabe
  1521.  
  1522. Der Formatstring "format" zur formatierten Ausgabe besteht aus
  1523. Formatkommandos und Ausgabezeichen. Die Formatkommandos bestimmen
  1524. den Typ der Parameter der Ausgabefunktion und die Art der Konver-
  1525. tierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind,
  1526. also nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und
  1527. werden unverändert ausgegeben.
  1528.  
  1529. Der Aufbau eines Formatkommandos:
  1530.  
  1531. % [flags] [width [.limit] ] [size] type
  1532.  
  1533. Die Angaben in den eckigen Klammern können optional angegeben werden.
  1534.  
  1535. flags
  1536. "-" zur Linksjustierung;
  1537. "+" zur Ausgabe auch eines positiven Vorzeichens bei Zahlen;
  1538. "0" zur Ausgabe führender Nullen bei Zahlen;
  1539. "#" zur Ausgabe von "0x" bei hexadezimalen Zahlen und "0" bei
  1540.     oktalen Zahlen
  1541.  
  1542. width
  1543. Feldbreite als dezimale Ziffernfolge oder "*", in diesem Fall wird
  1544. die Feldbreite als nächstes Argument des Typs int übergeben. Die
  1545. Feldbreite ist immer ein minimaler Wert, zu lange Ausgaben werden
  1546. nicht beschnitten.
  1547.  
  1548. limit
  1549. Die Genauigkeit als dezimale Ziffernfolge oder "*", in diesem Fall
  1550. wird die Genauigkeit als nächstes Argument des Typs int übergeben.
  1551. Der Wert beschreibt die maximale Anzahl von Zeichen bei Ausgabe
  1552. einer Zeichenkette oder die minimale Anzahl von Ziffern einer ganz-
  1553. zahligen Ausgabe.
  1554.  
  1555. size
  1556. Längenangabe des Arguments:
  1557. "h" für ein Argument des Typs short int oder unsigned short int;
  1558. "l" für ein Argument des Typs long int oder unsigned long int;
  1559.  
  1560. type
  1561. Typangabe des Arguments:
  1562.  
  1563. "d"
  1564. "i" zur Ausgabe einer vorzeichenbehafteten Dezimalzahl, das zuge-
  1565.     hörige Argument ist vom Typ int
  1566.  
  1567. "o" zur Ausgabe einer vorzeichenlosen Oktalzahl, das zugehörige
  1568.     Argument ist vom Typ int oder unsigned int
  1569.  
  1570. "x" zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Kleinbuch-
  1571.     staben, das zugehörige Argument ist vom Typ int oder unsigned int
  1572.  
  1573. "X" zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Großbuch-
  1574.     staben, das zugehörige Argument ist vom Typ int oder unsigned int
  1575.  
  1576. "u" zur Ausgabe einer vorzeichenlosen Dezimalzahl, das zugehörige
  1577.     Argument ist vom Typ unsigned int
  1578.  
  1579. "c" zur Ausgabe eines Zeichens, das zugehörige Argument ist vom Typ
  1580.     int und wird in unsigned char konvertiert
  1581.  
  1582. "s" zur Ausgabe einer Zeichenkette, die mit einem Nullzeichen abge-
  1583.     schlossen ist, das zugehörige Argument ist vom Typ char *
  1584.  
  1585. "p" zur Ausgabe einer hexadezimalen Speicheradresse, das zugehörige
  1586.     Argument ist vom Typ void *;
  1587.  
  1588. "n" zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf
  1589.     ausgegebenen Zeichen in der Variablen, auf die das Argument vom
  1590.     Typ int * zeigt, es erfolgt keine Ausgabe
  1591.  
  1592. "%" zur Ausgabe eines Prozentzeichens
  1593.  
  1594. Alle anderen Typangaben führen zu undefinierten Ausgaben.
  1595.  
  1596. ============================================================================
  1597.  
  1598. Der Ausgabeformatstring__ "format" zur formatierten Ausgabe
  1599.  
  1600. Der Formatstring "format" zur formatierten Ausgabe besteht aus
  1601. Formatkommandos und Ausgabezeichen. Die Formatkommandos bestimmen
  1602. den Typ der Parameter der Ausgabefunktion und die Art der Konver-
  1603. tierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind,
  1604. also nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und
  1605. werden unverändert ausgegeben.
  1606.  
  1607. Der Aufbau eines Formatkommandos:
  1608.  
  1609. % [flags] [width [.limit] ] [size] type
  1610.  
  1611. Die Angaben in den eckigen Klammern können optional angegeben werden.
  1612.  
  1613. flags
  1614. "-" zur Linksjustierung;
  1615. "+" zur Ausgabe auch eines positiven Vorzeichens bei Zahlen;
  1616. "0" zur Ausgabe führender Nullen bei Zahlen;
  1617. "#" hat keine Auswirkung
  1618.  
  1619. width
  1620. Feldbreite als dezimale Ziffernfolge oder "*", in diesem Fall wird
  1621. die Feldbreite als nächstes Argument des Typs int übergeben. Die
  1622. Feldbreite ist immer ein minimaler Wert, zu lange Ausgaben werden
  1623. nicht beschnitten.
  1624.  
  1625. limit
  1626. Die Genauigkeit als dezimale Ziffernfolge oder "*", in diesem Fall
  1627. wird die Genauigkeit als nächstes Argument des Typs int übergeben.
  1628. Der Wert beschreibt die maximale Anzahl von Zeichen bei Ausgabe
  1629. einer Zeichenkette oder  die minimale Anzahl von Ziffern einer ganz-
  1630. zahligen Ausgabe.
  1631.  
  1632. size
  1633. Längenangabe des Arguments:
  1634. "h" für ein Argument des Typs short int oder unsigned short int;
  1635. "l" für ein Argument des Typs long int oder unsigned long int;
  1636.  
  1637. type
  1638. Typangabe des Arguments:
  1639.  
  1640. "d"
  1641. "i" zur Ausgabe einer vorzeichenbehafteten Dezimalzahl, das zuge-
  1642.     hörige Argument ist vom Typ int
  1643.  
  1644. "c" zur Ausgabe eines Zeichens, das zugehörige Argument ist vom
  1645.     Typ int und wird in unsigned char konvertiert
  1646.  
  1647. "s" zur Ausgabe einer Zeichenkette, die mit einem Nullzeichen abge-
  1648.     schlossen ist, das zugehörige Argument ist vom Typ char *
  1649.  
  1650. "n" zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf
  1651.     ausgegebenen Zeichen in der Variablen, auf die das Argument vom
  1652.     Typ int * zeigt, es erfolgt keine Ausgabe
  1653.  
  1654. "%" zur Ausgabe eines Prozentzeichens
  1655.  
  1656. Alle anderen Typangaben führen zu undefinierten Ausgaben.
  1657.  
  1658. ============================================================================
  1659.  
  1660. Der Eingabeformatstring "format" zur formatierten Eingabe
  1661.  
  1662. Der Formatstring "format" zur formatierten Eingabe besteht aus den
  1663. Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen
  1664. den Typ der Parameter der Eingabefunktion und die Art der Konver-
  1665. tierung und Eingabe. Alle Zeichen, die kein Formatkommando sind,
  1666. also nicht mit dem Zeichen "%" beginnen und keine Trennzeichen (Leer-
  1667. zeichen, Tabulatoren und Zeilenvorschübe) sind, sind Eingabezeichen
  1668. und werden unverändert in der Eingabe erwartet.
  1669.  
  1670. Der Aufbau eines Formatkommandos:
  1671.  
  1672. % [width] [size] type
  1673.  
  1674. Die Angaben in den eckigen Klammern können optional angegeben werden.
  1675.  
  1676. width
  1677. Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder "*",
  1678. in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das
  1679. nächste Argument übertragen.
  1680.  
  1681. size
  1682. Längenangabe des Arguments:
  1683. "h" für ein Argument des Typs short int oder unsigned short int
  1684. "l" für ein Argument des Typs long int oder unsigned long int
  1685.  
  1686. type
  1687. Typangabe des Arguments:
  1688.  
  1689. "d" zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zuge-
  1690.     hörige Argument ist vom Typ int *
  1691.  
  1692. "i" zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei
  1693.     führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'),
  1694.     das zugehörige Argument ist vom Typ int *
  1695.  
  1696. "o" zur Eingabe einer Oktalzahl, das zugehörige Argument ist vom Typ int *
  1697.  
  1698. "x" zur Eingabe einer Hexadezimalzahl mit oder ohne '0x', das zugehörige
  1699.     Argument ist vom Typ int oder unsigned int
  1700.  
  1701. "c" zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner
  1702.     nicht überlesen werden und kein Nullzeichen angehängt wird, das zuge-
  1703.     hörige Argument ist vom Typ char *
  1704.  
  1705. "s" zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilen-
  1706.     trenner überlesen werden und ein Nullzeichen angehängt wird, das zuge-
  1707.     hörigen Argument ist vom Typ char *
  1708.  
  1709. "e"
  1710. "f"
  1711. "g" zur Eingabe einer Fließkommazahl in beliebiger Darstellung, das zuge-
  1712.     hörige Argument ist vom Typ float *
  1713.  
  1714. "p" zur Eingabe einer hexadezimalen Speicheradresse, das zugehörige Argument
  1715.     ist vom Typ int *
  1716.  
  1717. "n" zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gele-
  1718.     senen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt,
  1719.     es wird kein Zeichen gelesen.
  1720.  
  1721. "[...]"  zur Eingabe einer Zeichenkette, die nur aus den in den eckigen
  1722.      Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen ange-
  1723.      hängt wird, das zugehörigen Argument ist vom Typ char *
  1724.  
  1725. "[^...]" zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die
  1726.      nicht in den eckigen Klammern angegebenen sind, wobei ein Null-
  1727.      zeichen angehängt wird; das zugehörigen Argument ist vom Typ char *
  1728.  
  1729. "%%"     zur Eingabe eines Prozentzeichens
  1730.  
  1731. Alle anderen Typangaben führen zu undefinierten Eingaben.
  1732.  
  1733. ============================================================================
  1734.  
  1735. Der Eingabeformatstring_ "format" zur formatierten Eingabe
  1736.  
  1737. Der Formatstring "format" zur formatierten Eingabe besteht aus den
  1738. Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen
  1739. den Typ der Parameter der Eingabefunktion und die Art der Konver-
  1740. tierung und Eingabe. Alle Zeichen, die kein Formatkommando sind,
  1741. also nicht mit dem Zeichen "%" beginnen und keine Trennzeichen (Leer-
  1742. zeichen, Tabulatoren und Zeilenvorschübe) sind, sind Eingabezeichen
  1743. und werden unverändert in der Eingabe erwartet.
  1744.  
  1745. Der Aufbau eines Formatkommandos:
  1746.  
  1747. % [width] [size] type
  1748.  
  1749. Die Angaben in den eckigen Klammern können optional angegeben werden.
  1750.  
  1751. width
  1752. Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder "*",
  1753. in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das
  1754. nächste Argument übertragen.
  1755.  
  1756. size
  1757. Längenangabe des Arguments:
  1758. "h" für ein Argument des Typs short int oder unsigned short int
  1759. "l" für ein Argument des Typs long int oder unsigned long int
  1760.  
  1761. type
  1762. Typangabe des Arguments:
  1763.  
  1764. "d" zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zuge-
  1765.     hörige Argument ist vom Typ int *
  1766.  
  1767. "i" zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei
  1768.     führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'),
  1769.     das zugehörige Argument ist vom Typ int *
  1770.  
  1771. "o" zur Eingabe einer Oktalzahl, das zugehörige Argument ist vom Typ int *
  1772.  
  1773. "x" zur Eingabe einer Hexadezimalzahl mit oder ohne '0x', das zugehörige
  1774.     Argument ist vom Typ int oder unsigned int
  1775.  
  1776. "c" zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner
  1777.     nicht überlesen werden und kein Nullzeichen angehängt wird, das zuge-
  1778.     hörige Argument ist vom Typ char *
  1779.  
  1780. "s" zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilen-
  1781.     trenner überlesen werden und ein Nullzeichen angehängt wird, das zuge-
  1782.     hörigen Argument ist vom Typ char *
  1783.  
  1784. "p" zur Eingabe einer hexadezimalen Speicheradresse, das zugehörige Argument
  1785.     ist vom Typ int *
  1786.  
  1787. "n" zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gele-
  1788.     senen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt,
  1789.     es wird kein Zeichen gelesen.
  1790.  
  1791. "[...]"  zur Eingabe einer Zeichenkette, die nur aus den in den eckigen
  1792.      Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen ange-
  1793.      hängt wird, das zugehörigen Argument ist vom Typ char *
  1794.  
  1795. "[^...]" zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die
  1796.      nicht in den eckigen Klammern angegebenen sind, wobei ein Null-
  1797.      zeichen angehängt wird; das zugehörigen Argument ist vom Typ char *
  1798.  
  1799. "%%"     zur Eingabe eines Prozentzeichens
  1800.  
  1801. Alle anderen Typangaben führen zu undefinierten Eingaben.
  1802.  
  1803. ============================================================================
  1804.  
  1805. Der Eingabeformatstring__ "format" zur formatierten Eingabe
  1806.  
  1807. Der Formatstring "format" zur formatierten Eingabe besteht aus den
  1808. Formatkommandos und Eingabezeichen. Die Formatkommandos bestimmen
  1809. den Typ der Parameter der Eingabefunktion und die Art der Konver-
  1810. tierung und Eingabe. Alle Zeichen, die kein Formatkommando sind,
  1811. also nicht mit dem Zeichen "%" beginnen und keine Trennzeichen (Leer-
  1812. zeichen, Tabulatoren und Zeilenvorschübe) sind, sind Eingabezeichen
  1813. und werden unverändert in der Eingabe erwartet.
  1814.  
  1815. Der Aufbau eines Formatkommandos:
  1816.  
  1817. % [width] [size] type
  1818.  
  1819. Die Angaben in den eckigen Klammern können optional angegeben werden.
  1820.  
  1821. width
  1822. Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder "*",
  1823. in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das
  1824. nächste Argument übertragen.
  1825.  
  1826. size
  1827. Längenangabe des Arguments:
  1828. "h" für ein Argument des Typs short int oder unsigned short int
  1829. "l" für ein Argument des Typs long int oder unsigned long int
  1830.  
  1831. type
  1832. Typangabe des Arguments:
  1833.  
  1834. "d" zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zuge-
  1835.     hörige Argument ist vom Typ int *
  1836.  
  1837. "i" zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei
  1838.     führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'),
  1839.     das zugehörige Argument ist vom Typ int *
  1840.  
  1841. "c" zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner
  1842.     nicht überlesen werden und kein Nullzeichen angehängt wird, das zuge-
  1843.     hörige Argument ist vom Typ char *
  1844.  
  1845. "s" zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilen-
  1846.     trenner überlesen werden und ein Nullzeichen angehängt wird, das zuge-
  1847.     hörigen Argument ist vom Typ char *
  1848.  
  1849. "n" zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gele-
  1850.     senen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt,
  1851.     es wird kein Zeichen gelesen.
  1852.  
  1853. "[...]"  zur Eingabe einer Zeichenkette, die nur aus den in den eckigen
  1854.      Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen ange-
  1855.      hängt wird, das zugehörigen Argument ist vom Typ char *
  1856.  
  1857. "[^...]" zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die
  1858.      nicht in den eckigen Klammern angegebenen sind, wobei ein Null-
  1859.      zeichen angehängt wird; das zugehörigen Argument ist vom Typ char *
  1860.  
  1861. "%%"     zur Eingabe eines Prozentzeichens
  1862.  
  1863. Alle anderen Typangaben führen zu undefinierten Eingaben.
  1864.  
  1865. ============================================================================
  1866.  
  1867. Beispiele:
  1868. ~~~~~~~~~~
  1869.  
  1870. Um die Vorteile und Anwendungsmöglichkeiten der "stormamiga.lib"
  1871. etwas zu verdeutlichen, habe ich ein paar Beispiele beigelegt.
  1872.  
  1873. Die Beispiele mit dem Namen "...-storm" werden mit der "storm.lib"
  1874. und dem Startupcode "startup.o" gelinkt.
  1875.  
  1876. Die Beispiele mit dem Namen "...-stormamiga" werden mit der
  1877. "stormamiga.lib" und dem Startupcode "stormamiga_startups.o" gelinkt.
  1878.  
  1879. Die Beispiele mit dem Namen "...-stormamiga-2" werden mit der
  1880. "stormamiga.lib" und dem Startupcode "stormamiga_startups.o" gelinkt.
  1881. Außerdem wurde der Quelltext für die "stormamiga.lib" optimiert.
  1882.  
  1883. ============================================================================
  1884.  
  1885. Bekannte Fehler:
  1886. ~~~~~~~~~~~~~~~~
  1887.  
  1888. - Der Befehl "printf" hat bei der Ausgabe von Fließkommazahlen einen
  1889.   Rundungsfehler.
  1890.  
  1891. ============================================================================
  1892.  
  1893. Updates:
  1894. ~~~~~~~~
  1895.  
  1896. Wenn Sie Zugang zum Internet haben, dann können Sie die Updates auf
  1897. der HomePage "http://home.pages.de/~haage" der Haage & Partner
  1898. Computer GmbH bekommen.
  1899. Sie können die neueste Version natürlich auch direkt von mir bekommen.
  1900. Allerdings müssen Sie mir dann einen frankierten Briefumschlag und
  1901. eine Diskette (HD oder DD) zuschicken.
  1902.  
  1903. ============================================================================
  1904.  
  1905. Kopierrecht:
  1906. ~~~~~~~~~~~~
  1907.  
  1908. Die "stormamiga.lib" ist FREEWARE. Sie darf frei kopiert werden, solange
  1909. sie in KEINSTER Weise verändert wird und solange ALLE dazugehörigen
  1910. Dateien UNVERÄNDERT mitkopiert werden.
  1911.  
  1912. Die "stormamiga.lib" darf auch im Zusammenhang mit anderen Programmen
  1913. verwendet und vertrieben werden, solange KLARGESTELLT ist, daß es sich um
  1914. FREEWARE handelt UND solange ALLE Dateien UNVERÄNDERT mitkopiert werden.
  1915. Mit der Weitergabe der "stormamiga.lib" darf kein Gewinn erzielt werden.
  1916. Der Verkaufspreis einer Diskette, die die "stormamiga.lib" enthält, darf
  1917. nicht mehr als 5,- DM betragen. Ausgenommen davon sind Disketten, die es
  1918. zu Zeitschriften gibt.
  1919.  
  1920. Eine Reassemblierung der "stormamiga.lib" ist selbstverständlich NICHT
  1921. gestattet.
  1922.  
  1923. AM WICHTIGSTEN:
  1924.  
  1925.  
  1926. Die Benutzung der "stormamiga.lib" erfolgt AUSSCHLIEßLICH auf eigenes Risiko.
  1927.  
  1928. Der Autor kann auf KEINEN FALL für einen Schaden oder Datenverlust der direkt
  1929. oder indirekt mit dem Gebrauch der "stormamiga.lib" entstehen sollte verant-
  1930. wortlich gemacht werden.
  1931.  
  1932. Alle Rechte vorbehalten. Für Fehlermitteilungen oder Verbesserungsvorschläge
  1933. bin ich jederzeit dankbar.
  1934.  
  1935. ============================================================================
  1936.  
  1937. Geschichte:
  1938. ~~~~~~~~~~~
  1939.  
  1940. V41.000 alpha - V41.002 alpha (18.03. - 21.03.1996):
  1941. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  1942.   interne Entwicklungsphase
  1943.  
  1944. - Funktionen der "amiga.lib" für MC68000 oder höher geschrieben
  1945.  
  1946.  
  1947. V41.003 alpha - V41.021 alpha (22.03. - 16.05.1996):
  1948. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  1949.   interne Entwicklungsphase
  1950.  
  1951. - Funktionen der "amiga.lib" für MC68EC020 oder höher umgeschrieben (ab
  1952.   V41.003 alpha wird ein MC68EC020 oder höher benötigt)
  1953. - Ein- und Ausgaberoutinen geschrieben (GCC-kompatibel)
  1954. - Funktionen zum automatischen Öffnen und Schließen der Libraries ge-
  1955.   schrieben
  1956. - die meisten ctype-Funktionen geschrieben
  1957. - einige stdio-, string- und stdlib-Funktionen geschrieben
  1958. - Startupcode für die "stormamiga.lib" optimiert
  1959. - einige andere Funktionen geschrieben
  1960. - einige Optimierungen und Fehlerkorrekturen
  1961. - Includedatei "stormamiga.h" geschrieben
  1962.  
  1963.  
  1964. V41.022 alpha - V41.029 alpha (20.05. - 11.06.1996):
  1965. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  1966.   interne Entwicklungsphase
  1967.  
  1968. - Ein- und Ausgaberoutinen komplett neu geschrieben (StormC-kompatibel)
  1969. - einige stdio-Funktionen geschrieben
  1970. - 64Bit Befehle der "storm.lib" für MC68EC020+ optimiert
  1971. - einige andere Funktionen geschrieben
  1972. - einige Optimierungen und Fehlerkorrekturen
  1973. - Includedatei "stormamiga.h" erweitert
  1974. - Anleitung geschrieben
  1975.  
  1976.  
  1977. Hinweis:
  1978.  
  1979. Durch ein Versehen wurde die Version 41.028 alpha, einige uralte Beispiel-
  1980. programme und Teile der Anleitung, mit der Version 1.1 von StormC, veröffent-
  1981. licht. Diese Version hatt aber noch einige größere Fehler und funktioniert
  1982. nicht mit den alten Beispielprogrammen.
  1983. Die erste, zur Veröffentlichung gedachte Version, ist die Version 41.032 beta.
  1984.  
  1985.  
  1986. V41.030 beta - V41.031 beta (13.06. - 15.06.1996):
  1987. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  1988.   interne Entwicklungs- und Testphase
  1989.  
  1990. - Optimierung der Ein- und Ausgaberoutinen
  1991. - Fehlerkorrekturen
  1992. - Anleitung überarbeitet
  1993.  
  1994.  
  1995. V41.032 beta (16.06.1996):
  1996. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  1997.   Erste öffentliche Version
  1998.  
  1999.  
  2000. V41.033 beta (17.06. - 15.07.1996):
  2001. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  2002. - umfangreiches Betatesting
  2003. - Fehlerkorrektur der string-Funktion "memcpy" (Die Benutzung von "memcpy"
  2004.   führte zu einem Fehler oder zum Systemabsturz. Die Ursache war ein Tipp-
  2005.   fehler. Ich hatte "a2" statt "a1" geschrieben.)
  2006. - die mathematischen Funktionen "acos", "asin", "atan", "ceil", "cos",
  2007.   "cosh", "exp", "fabs", "floor", "log", "log10", "pow", "sin", "sinh",
  2008.   "sqrt", "tan" und "tanh" geschrieben
  2009. - die string-Funktionen "memccpy", "strcoll", "strlwr", "strsep", "strupr",
  2010.   "strxfrm" und "swab" geschrieben
  2011. - die stdlib-Funktionen "abs", "labs", "atoi", "atol" geschrieben
  2012. - die stdlib-Funktion "rand" optimiert
  2013. - die string-Funktionen "memchr", "memmove", "memset", "strcspn", "strpbrk",
  2014.   "strspn" und "strtok" optimiert
  2015. - Includedatei "stormamiga.h" überarbeitet und erweitert
  2016.  
  2017.  
  2018. V41.034 (16.07. - 31.07.1996):
  2019. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  2020. - Fehlerkorrektur der internen Funktion "amigawrite" (Der auszugebende Text wurde
  2021.   erst nach einigen Sekunden angezeigt. Bei dem Programm "GadTools" wurde der Text
  2022.   erst ausgegeben, wenn 5 Schalter gedrückt wurden.)
  2023. - die string-Funktionen "strerror" und "stricmp" geschrieben
  2024. - die string-Funktionen "memcmp", "strcat", "strcmp", "strcpy", "strncat",
  2025.   "strncmp", "strncpy" und "strstr" optimiert
  2026. - die stdlib-Funktionen "malloc" und "free" optimiert
  2027. - die stdio-Funktionen "vfprintf", "vfprintf_", "vfprintf__", "vfscanf",
  2028.   "vfscanf_", "vfscanf__", "fflush" und "setvbuf" optimiert
  2029. - die internen Funktionen "amigaread", "amigareadunget", "amigawrite", "amiga-
  2030.   eof", "amigaseek", "amigagetc", "amigagetcunget", "amigaungetc", "amigaputc",
  2031.   "amigaflush", "amigaclose", "SMult64", "UMult64", "SDiv64", "INIT_0_InitFiles",
  2032.   "EXIT_5_InitFiles", "INIT_5_InitStdIOFiles", "EXIT_5_InitStdIOFiles" und
  2033.   "EXIT_4_free" optimiert
  2034. - "aufräumen" der "stormamiga.lib" (dadurch wird das Linken beschleunigt,
  2035.   die Programme etwas schneller und die Map-Datei übersichtlicher)
  2036. - Anleitung überarbeitet
  2037.  
  2038.  
  2039. V41.035 (02.08. - 17.08.1996):
  2040. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  2041. - die string-Funktionen "strcmp", "strcoll" und "strxfrm" neu geschrieben
  2042. - die stdlib-Funktionen "llabs",  "atoll", "strtol", "strtoll", "strtoul",
  2043.   "strtoull", "inttostr", "llongtostr", "uinttostr" und "ullongtostr"
  2044.   geschrieben
  2045. - die stdio-Funktion "puts" geschrieben
  2046. - die Spezial-Funktionen "muls64" und "mulu64" geschrieben
  2047. - Includedatei "stormamiga.h" erweitert
  2048. - Benutzer-Lexikon mit allen Sonder-Funktionen der "stormamiga.lib" geschrieben
  2049. - Installerskript geschrieben
  2050. - Anleitung überarbeitet (Beschreibung der Funktionen neu geschrieben, Index
  2051.   hinzugefügt und an AmigaOS 3.0 angepaßt); Anleitung als ASCII-Text beigelegt
  2052.  
  2053. ============================================================================
  2054.  
  2055. In Zukunft:
  2056. ~~~~~~~~~~~
  2057.  
  2058. Die folgenden Punkte habe ich mir für die nächsten Versionen der
  2059. "stormamiga.lib" vorgenommen.
  2060.  
  2061. - alle, noch fehlenden, Funtionen der "storm.lib" und der "amiga.lib"
  2062.   in die "stormamiga.lib" integrieren
  2063.  
  2064. - Unterstützung des kleinen Datenmodelles a4 (eventuell auch a6)
  2065.  
  2066. - spezielle Version der "stormamiga.lib" für die Koprozessoren
  2067.   MC68881 und MC68882 (mit "68040.library" bzw. "68060.library"
  2068.   auch für den MC68040 und MC68060)
  2069.  
  2070. - spezielle Version der "stormamiga.lib" für den MC68040 (mit
  2071.   "68060.library" auch für den MC68060)
  2072.  
  2073. ============================================================================
  2074.  
  2075. Danksagungen:
  2076. ~~~~~~~~~~~~~
  2077.  
  2078. Als erstes möchte ich mich bei der Haage & Partner Computer GmbH
  2079. bedanken, weil sie mir ihre Entwicklerunterlagen und Quelltexte
  2080. kostenlos überlassen haben. Ohne diese Unterlagen währe ich wahr-
  2081. scheinlich an den Ein- und Ausgaberoutinen für die Befehle printf
  2082. und scanf verzweifelt.
  2083. Besonderen Dank an Jochen Becher, der auch an Sonntagen zu später
  2084. Stunde Zeit für meine Probleme hatte.
  2085.  
  2086. Ohne die Unterstützung der Haage & Partner Computer GmbH würde
  2087. es die "stormamiga.lib", in dieser Form, nicht geben.
  2088.  
  2089.  
  2090. Außerdem möchte ich mich bei folgenden Leuten bedanken:
  2091. ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
  2092. - Uwe Schienbein, für Betatesting, Bugreports und neue Ideen
  2093. - Carsten Bornholz, für Betatesting
  2094. - Dietmar Heidrich, für seinen "OMA"
  2095. - Frank Wille, für seinen "FreePhxAss"
  2096.  
  2097. ============================================================================
  2098.  
  2099. Autor:
  2100. ~~~~~~
  2101.  
  2102.                Matthias Henze
  2103.               Gorkistraße  119
  2104.                04347 Leipzig
  2105.                 Deutschland
  2106.  
  2107.             Telefon: 0341/2326414
  2108. ============================================================================
  2109.